﻿#ifndef __SS_MATRIX_H__
#define __SS_MATRIX_H__
#include <memory.h>
#include "../3dMath/ss3dMathDefine.h"

namespace StarSeeker
{
/////////////////////////////////float2x2//////////////////////////////////
class ssFLOAT2x2X : public ssFLOAT2x2
{
public:
	ssFLOAT2x2X();
	~ssFLOAT2x2X();
	ssFLOAT2x2X(ssfloat p11, ssfloat p12, ssfloat p21, ssfloat p22);
	ssFLOAT2x2X(const ssFLOAT2x2X &val);
	void operator=(const ssFLOAT2x2X &val);

	operator ssfloat* ();
	operator const ssfloat* () const;

	void Zero();
	//单位化
	void Identity();
	//转置
	void Transpose();
	//行列式求值
	ssfloat Determinant();
	//逆矩阵
	bool Invert();

	void operator *= (const ssFLOAT2x2X &val);
	void operator += (const ssFLOAT2x2X &val);
	void operator -= (const ssFLOAT2x2X &val);
	void operator *= (ssfloat val);
	void operator /= (ssfloat val);

	ssFLOAT2x2X operator * (const ssFLOAT2x2X &val) const;
	ssFLOAT2x2X operator + (const ssFLOAT2x2X &val) const;
	ssFLOAT2x2X operator - (const ssFLOAT2x2X &val) const;
	ssFLOAT2x2X operator * (ssfloat val) const;
	ssFLOAT2x2X operator / (ssfloat val) const;
	ssFLOAT2x2X operator - ();

	bool operator == (const ssFLOAT2x2X &val) const;
	bool operator != (const ssFLOAT2x2X &val) const;
};
typedef ssFLOAT2x2X ssMatrix2x2;
//常量单位矩阵
const ssFLOAT2x2X cg_identityMat2x2(1.f, 0.f,
									0.f, 1.f);
///////////////////////////////////////////////////////////////////////////
/////////////////////////////////float3x3//////////////////////////////////
class ssFLOAT3x3X : public ssFLOAT3x3
{
public:
	ssFLOAT3x3X();
	~ssFLOAT3x3X();
	ssFLOAT3x3X(ssfloat p11, ssfloat p12, ssfloat p13,
				ssfloat p21, ssfloat p22, ssfloat p23,
				ssfloat p31, ssfloat p32, ssfloat p33);
	ssFLOAT3x3X(const ssfloat* val);
	ssFLOAT3x3X(const ssFLOAT3x3X &val);
	void operator=(const ssFLOAT3x3X &val);

	operator ssfloat* ();
	operator const ssfloat* () const;

	void Zero();
	//单位化
	void Identity();
	//转置
	void Transpose();
	//行列式求值
	ssfloat Determinant();
	//逆矩阵
	bool Invert();
	//获取方向轴
	ssFLOAT3 GetAxisX();
	ssFLOAT3 GetAxisY();
	ssFLOAT3 GetAxisZ();

	void operator *= (const ssFLOAT3x3X &val);
	void operator += (const ssFLOAT3x3X &val);
	void operator -= (const ssFLOAT3x3X &val);
	void operator *= (ssfloat val);
	void operator /= (ssfloat val);

	ssFLOAT3x3X operator * (const ssFLOAT3x3X &val) const;
	ssFLOAT3x3X operator + (const ssFLOAT3x3X &val) const;
	ssFLOAT3x3X operator - (const ssFLOAT3x3X &val) const;
	ssFLOAT3x3X operator * (ssfloat val) const;
	ssFLOAT3x3X operator / (ssfloat val) const;

	bool operator == (const ssFLOAT3x3X &val) const;
	bool operator != (const ssFLOAT3x3X &val) const;
};
typedef ssFLOAT3x3X ssMatrix3x3;
//常量单位矩阵
const ssFLOAT3x3X cg_identityMat3x3(1.f,0.f,0.f,
									0.f,1.f,0.f,
									0.f,0.f,1.f);
///////////////////////////////////////////////////////////////////////////
///////////////////////////////ssFLOAT4x4X////////////////////////////////
class ssFLOAT4x4X : public ssFLOAT4x4
{
public:
	ssFLOAT4x4X();
	~ssFLOAT4x4X();
	ssFLOAT4x4X(ssfloat p11, ssfloat p12, ssfloat p13, ssfloat p14,
				ssfloat p21, ssfloat p22, ssfloat p23, ssfloat p24,
				ssfloat p31, ssfloat p32, ssfloat p33, ssfloat p34,
				ssfloat p41, ssfloat p42, ssfloat p43, ssfloat p44);
	ssFLOAT4x4X(const ssfloat* val);
	ssFLOAT4x4X(const ssFLOAT4x4X &val);
	void operator=(const ssFLOAT4x4X &val);

	operator ssfloat* ();
	operator const ssfloat* () const;

	void Zero();
	//单位化
	void Identity();
	//当作3x3矩阵
	void Convert3x3();
	//复制3x3矩阵的值
	void CopyFrom3x3(ssFLOAT3x3X& f3);
	//转置
	void Transpose();
	//行列式求值
	ssfloat Determinant();
	//求余子数
	ssfloat Cofactor(ssfloat m0, ssfloat m1, ssfloat m2,ssfloat m3, ssfloat m4, 
					ssfloat m5, ssfloat m6, ssfloat m7, ssfloat m8);
	//欧几里得变换矩阵求逆
	void InvertEuclidean();
	//仿射变换矩阵求逆
	void InvertAffine();
	//投影矩阵求逆
	bool InvertProjective();
	//一般的矩阵求逆
	bool InvertGeneral();
	//逆矩阵
	bool Invert();
	//获取方向轴
	ssFLOAT3 GetAxisX();
	ssFLOAT3 GetAxisY();
	ssFLOAT3 GetAxisZ();
	ssFLOAT3 GetOriginPoint();

	void operator *= (const ssFLOAT4x4X &val);
	void operator += (const ssFLOAT4x4X &val);
	void operator -= (const ssFLOAT4x4X &val);
	void operator *= (ssfloat val);
	void operator /= (ssfloat val);

	ssFLOAT4x4X operator * (const ssFLOAT4x4X &val) const;
	ssFLOAT4x4X operator + (const ssFLOAT4x4X &val) const;
	ssFLOAT4x4X operator - (const ssFLOAT4x4X &val) const;
	ssFLOAT4x4X operator * (ssfloat val) const;
	ssFLOAT4x4X operator / (ssfloat val) const;

	bool operator == (const ssFLOAT4x4X &val) const;
	bool operator != (const ssFLOAT4x4X &val) const;
};
typedef ssFLOAT4x4X ssMatrix4x4;
//常量单位矩阵
const ssFLOAT4x4X cg_identityMat4x4(1.f,0.f,0.f,0.f,
									0.f,1.f,0.f,0.f,
									0.f,0.f,1.f,0.f,
									0.f,0.f,0.f,1.f);
///////////////////////////////////////////////////////////////////////////
/////////////////////////////////float4x3//////////////////////////////////
class ssFLOAT4x3X : public ssFLOAT4x3
{
public:
	ssFLOAT4x3X();
	~ssFLOAT4x3X();
	ssFLOAT4x3X(ssfloat p11, ssfloat p12, ssfloat p13,
				ssfloat p21, ssfloat p22, ssfloat p23,
				ssfloat p31, ssfloat p32, ssfloat p33,
				ssfloat p41, ssfloat p42, ssfloat p43);
	ssFLOAT4x3X(const ssFLOAT4x3X &val);
	void operator=(const ssFLOAT4x3 &val);

	operator ssfloat* ();
	operator const ssfloat* () const;

	void Zero();
	//单位化
	void Identity();
	//行列式求值当做4x4矩阵
	ssfloat Determinant4x4();

	bool operator == (const ssFLOAT4x3X &val) const;
	bool operator != (const ssFLOAT4x3X &val) const;
};
typedef ssFLOAT4x3X ssMatrix4x3;
//常量单位矩阵
const ssFLOAT4x3X cg_identityMat4x3(1.f, 0.f, 0.f, 0.f,
									0.f, 1.f, 0.f, 0.f,
									0.f, 0.f, 1.f, 0.f);
///////////////////////////////////////////////////////////////////////////

}
#endif
